#pragma once
#include "matcher.hpp"
#include "online.hpp"
#include "room.hpp"
#include "session.hpp"
#include "Util.hpp"
#include "../rpc_client/Rpc_client.hpp"
#define WWWROOT "./wwwroot"
#define HTML404 "./wwwroot/404.html"

class weiqi_server
{
public:
    // 进行成员初始化，以及服务器回调函数的设置
    weiqi_server(Rpc::Client::RpcClient::ptr clientp,
                 const std::string &wwwroot = WWWROOT)
        : _web_root(wwwroot), _clientp(clientp), _rm(&_om, clientp), _sm(&_wssrv), _mm(&_rm, &_om, clientp)
    {
        _wssrv.set_access_channels(websocketpp::log::alevel::none); // 设置websocketpp日志等级
        _wssrv.init_asio();
        _wssrv.set_reuse_addr(true); // 设置地址复用
        _wssrv.set_http_handler(std::bind(&weiqi_server::http_callback, this, std::placeholders::_1));
        _wssrv.set_open_handler(std::bind(&weiqi_server::wsopen_callback, this, std::placeholders::_1));
        _wssrv.set_close_handler(std::bind(&weiqi_server::wsclose_callback, this, std::placeholders::_1));
        _wssrv.set_message_handler(std::bind(&weiqi_server::wsmsg_callback, this, std::placeholders::_1, std::placeholders::_2));
        ILOG("ws_server init success!");
    }
    // 启动服务器
    void start(int port)
    {
        _wssrv.listen(port);
        _wssrv.start_accept();
        _wssrv.run();
    }

private:
    // http回调函数
    void http_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string method = req.get_method();
        std::string uri = req.get_uri();
        if (method == "POST" && uri == "/reg") // 供前端页面发送消息后调用
        {
            ILOG("uri:%s", uri.c_str());
            return reg(conn);
        }
        else if (method == "POST" && uri == "/login")
        {
            return login(conn);
        }
        else if (method == "GET" && uri == "/info")
        {
            return info(conn);
        }
        else
        {
            return file_handler(conn);
        }
    }

    // 用户注册功能请求的处理
    void reg(wsserver_t::connection_ptr &conn)
    {
        websocketpp::http::parser::request req = conn->get_request();
        // 获取到请求正文
        std::string req_body = conn->get_request_body();
        // 对正文进行json反序列化，得到用户名和密码
        Json::Value reg_info;
        bool ret = json_util::deserialize(req_body, reg_info);
        if (ret == false)
        {
            DLOG("reg: deserialize failed");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }
        // 进行数据库的用户新增操作
        if (reg_info["username"].isNull() || reg_info["password"].isNull())
        {
            DLOG("用户名密码不完整");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        Json::Value params, result;
        params["username"] = reg_info["username"];
        params["password"] = reg_info["password"];

        if (!_clientp->call("user_insert", params, result))
        {
            ELOG("server: user_insert rpc call failed!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "内部错误!(rpc failed)");
        }
        if (result["result"] == false)
        {
            DLOG("向数据库插入数据失败!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名已经被占用!");
        }
        //  如果成功了，则返回200
        return http_resp(conn, true, websocketpp::http::status_code::ok, "注册用户成功");
    }

    // 用户登录功能请求的处理
    void login(wsserver_t::connection_ptr &conn)
    {
        // 获取到请求正文
        std::string req_body = conn->get_request_body();
        // 对正文进行json反序列化，得到用户名和密码
        Json::Value login_info;
        bool ret = json_util::deserialize(req_body, login_info);
        if (ret == false)
        {
            DLOG("反序列化登录信息失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }
        // 校验正文完整性，进行数据库的用户信息验证
        if (login_info["username"].isNull() || login_info["password"].isNull())
        {
            DLOG("用户名密码不完整");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        Json::Value params, result;
        params["username"] = login_info["username"];
        params["password"] = login_info["password"];
        if (!_clientp->call("user_login", params, result))
        {
            ELOG("server: user_login rpc call failed!");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "内部错误!(rpc failed)");
        }
        if (!result["result"].asBool())
        {
            // 如果验证失败，则返回400
            std::string err_str = result["reson"].asString();
            if (err_str == "username or password error")
            {
                DLOG("用户名或密码错误");
                return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名或密码错误");
            }
            else
            {
                ELOG("server: login failed: %s", err_str.c_str());
                return http_resp(conn, false, websocketpp::http::status_code::bad_request, err_str);
            }
        }
        // 如果验证成功，给客户端创建session
        uint64_t uid = result["id"].asUInt64();
        session_ptr ssp = _sm.create_session(uid, LOGIN);
        if (ssp.get() == nullptr)
        {
            ELOG("创建会话失败");
            return http_resp(conn, false, websocketpp::http::status_code::internal_server_error, "创建会话失败");
        }
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        // 4. 设置响应头部：Set-Cookie,将sessionid通过cookie返回
        std::string cookie_ssid = "SSID=" + std::to_string(ssp->ssid());
        conn->append_header("Set-Cookie", cookie_ssid);
        return http_resp(conn, true, websocketpp::http::status_code::ok, "登录成功");
    }

    // 用户信息获取功能请求的处理
    void info(wsserver_t::connection_ptr &conn)
    {
        Json::Value err_resp;
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // 如果没有cookie，返回错误：没有cookie信息，让客户端重新登录
            return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到cookie信息，请重新登录(请允许浏览器使用cookie!)");
        }
        // 从cookie中取出ssid
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            // cookie中没有ssid，返回错误：没有ssid信息，让客户端重新登录
            return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到ssid信息，请重新登录(请允许浏览器使用cookie!)");
        }
        // 在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            // 没有找到session，则认为登录已经过期，需要重新登录
            return http_resp(conn, true, websocketpp::http::status_code::bad_request, "登录过期，请重新登录");
        }
        // 从数据库中取出用户信息，进行序列化发送给客户端
        uint64_t uid = ssp->get_user();
        Json::Value params, result;
        params["uid"] = uid;
        ILOG("UID:%ld", uid);
        if (!_clientp->call("select_by_id", params, result))
        {
            ELOG("server: select_by_id rpc call failed!");
            return http_resp(conn, true, websocketpp::http::status_code::bad_request, "内部错误!(rpc failed)");
        }
        if (result["result"] == false)
        {
            // 获取用户信息失败，返回错误：找不到用户信息
            if (result["reason"].asString() == "uid have no info!")
            {
                return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到用户信息，请重新登录");
            }
            else
            {
                std::string err_str = result["reason"].asString();
                ELOG("server: select_by_id failed: %s", err_str.c_str());
                return http_resp(conn, true, websocketpp::http::status_code::bad_request, err_str);
            }
        }
        std::string body;
        result.removeMember("reason");
        json_util::serialize(result, body);
        conn->set_body(body);
        conn->append_header("Content-Type", "application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        // 刷新session的过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    // 静态资源请求的处理
    void file_handler(wsserver_t::connection_ptr &conn)
    {
        // 获取到请求uri-资源路径，得到客户端请求的页面文件名称
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        // 组合出文件的实际路径:相对根目录 + uri
        std::string realpath = _web_root + uri;
        // 如果请求的是根目录，则访问./wwwroot/login.html
        if (realpath.back() == '/')
        {
            realpath = "./wwwroot/login.html";
        }
        // 读取文件内容
        Json::Value resp_json;
        std::string body;
        bool ret = file_util::read(realpath, body);
        if (ret == false)
        {
            // 如果文件不存在，读取文件内容失败，返回404页面
            body.resize(0);
            if (!file_util::read(HTML404, body))
            {
                ELOG("read 404.html failed!");
            }
            conn->set_status(websocketpp::http::status_code::not_found);
            conn->set_body(body);
            return;
        }
        // 5. 设置响应正文
        conn->set_body(body);
        conn->set_status(websocketpp::http::status_code::ok);
    }

    bool get_cookie_val(const std::string &cookie_str, const std::string &key, std::string &val)
    {
        // Cookie: SSID=XXX; path=/;
        // 以; 作为间隔，对字符串进行分割，得到各个单个的cookie信息
        std::string sep = "; ";
        std::vector<std::string> cookie_arr;
        string_util::split(cookie_str, sep, cookie_arr);
        for (auto str : cookie_arr)
        {
            // 对单个cookie字符串，以=为间隔进行分割，得到key和val
            std::vector<std::string> tmp_arr;
            string_util::split(str, "=", tmp_arr);
            if (tmp_arr.size() != 2)
            {
                continue;
            }
            if (key == tmp_arr[0])
            {
                val = tmp_arr[1];
                return true;
            }
        }
        return false;
    }

    void http_resp(wsserver_t::connection_ptr &conn, bool result, websocketpp::http::status_code::value code, const std::string &reason)
    {
        Json::Value resp_json;
        resp_json["result"] = result;
        resp_json["reason"] = reason;
        std::string resp_body;
        json_util::serialize(resp_json, resp_body);
        conn->set_status(code);
        conn->set_body(resp_body);
        conn->append_header("Content-Type", "application/json");
        return;
    }

    // websocket长连接建立成功之后的回调处理函数
    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            // 建立与游戏大厅的长连接
            return wsopen_game_hall(conn);
        }
        else if (uri == "/room")
        {
            // 建立与游戏房间的长连接
            return wsopen_game_room(conn);
        }
    }

    // 游戏大厅长连接建立
    void wsopen_game_hall(wsserver_t::connection_ptr conn)
    {
        Json::Value resp_json;
        // 登录验证--判断当前客户端是否已经成功登录
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 2. 判断当前客户端是否是重复登录
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            resp_json["optype"] = "hall_ready";
            resp_json["reason"] = "玩家重复登录！";
            resp_json["result"] = false;
            return ws_resp(conn, resp_json);
        }
        // 将当前客户端以及连接加入到游戏大厅
        _om.enter_game_hall(ssp->get_user(), conn);
        // 给客户端响应游戏大厅连接建立成功
        resp_json["optype"] = "hall_ready";
        resp_json["result"] = true;
        ws_resp(conn, resp_json);
        // 将session设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
    }

    // 游戏房间长连接建立
    void wsopen_game_room(wsserver_t::connection_ptr conn)
    {
        Json::Value resp_json;
        // 获取当前客户端的session
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 当前用户是否已经在在线用户管理的游戏房间或者游戏大厅中
        if (_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            resp_json["optype"] = "room_ready";
            resp_json["reason"] = "玩家重复登录！";
            resp_json["result"] = false;
            return ws_resp(conn, resp_json);
        }
        // 判断当前用户是否已经创建好了房间
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr)
        {
            resp_json["optype"] = "room_ready";
            resp_json["reason"] = "没有找到玩家的房间信息";
            resp_json["result"] = false;
            return ws_resp(conn, resp_json);
        }
        // 将当前用户添加到在线用户管理的游戏房间中
        _om.enter_game_room(ssp->get_user(), conn);
        // 将session重新设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
        // 回复房间准备完毕
        resp_json["optype"] = "room_ready";
        resp_json["result"] = true;
        resp_json["room_id"] = (Json::UInt64)rp->id();
        resp_json["uid"] = (Json::UInt64)ssp->get_user();
        uint64_t white_id = (Json::UInt64)rp->get_white_user();
        uint64_t black_id = (Json::UInt64)rp->get_black_user();
        resp_json["white_id"] = white_id;
        resp_json["black_id"] = black_id;
        Json::Value v_white_id, v_black_id;
        Json::Value white_val, black_val;
        white_val["username"] = "AI";
        if (white_id != UINT64_MAX)
        {
            v_white_id["uid"] = white_id;
            if (!_clientp->call("select_by_id", v_white_id, white_val))
            {
                ELOG("server: select_by_id rpc call failed!");
                return http_resp(conn, true, websocketpp::http::status_code::bad_request, "内部错误!(rpc failed)");
            }
            if (white_val["result"] == false)
            {
                // 获取用户信息失败，返回错误：找不到用户信息
                if (white_val["reason"].asString() == "uid have no info!")
                {
                    return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到用户信息，请重新登录");
                }
                else
                {
                    std::string err_str = white_val["reason"].asString();
                    ELOG("server: select_by_id failed: %s", err_str.c_str());
                    return http_resp(conn, true, websocketpp::http::status_code::bad_request, err_str);
                }
            }
        }

        if (black_id != UINT64_MAX)
        {
            v_black_id["uid"] = black_id;
            if (!_clientp->call("select_by_id", v_black_id, black_val))
            {
                ELOG("server: select_by_id rpc call failed!");
                return http_resp(conn, true, websocketpp::http::status_code::bad_request, "内部错误!(rpc failed)");
            }
            if (black_val["result"] == false)
            {
                // 获取用户信息失败，返回错误：找不到用户信息
                if (black_val["reason"].asString() == "uid have no info!")
                {
                    return http_resp(conn, true, websocketpp::http::status_code::bad_request, "找不到用户信息，请重新登录");
                }
                else
                {
                    std::string err_str = black_val["reason"].asString();
                    ELOG("server: select_by_id failed: %s", err_str.c_str());
                    return http_resp(conn, true, websocketpp::http::status_code::bad_request, err_str);
                }
            }
        }

        resp_json["white_name"] = white_val["username"];
        resp_json["black_name"] = black_val["username"];
        resp_json["white_score"] = white_val["score"];
        resp_json["black_score"] = black_val["score"];
        resp_json["white_win"] = white_val["win_count"];
        resp_json["black_win"] = black_val["win_count"];
        return ws_resp(conn, resp_json);
    }

    void ws_resp(wsserver_t::connection_ptr conn, Json::Value &resp)
    {
        std::string body;
        json_util::serialize(resp, body);
        conn->send(body);
    }

    session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn)
    {
        // 获取请求信息中的Cookie，从Cookie中获取ssid
        Json::Value err_resp;
        std::string cookie_str = conn->get_request_header("Cookie");
        if (cookie_str.empty())
        {
            // 如果没有cookie，返回错误：没有cookie信息，让客户端重新登录
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "没有找到cookie信息，请重新登录";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        // 从cookie中取出ssid
        std::string ssid_str;
        bool ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if (ret == false)
        {
            // cookie中没有ssid，返回错误：没有ssid信息，让客户端重新登录
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "没有找到本地SSID信息，请重新登录";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        // 在session管理中查找对应的会话信息
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if (ssp.get() == nullptr)
        {
            // 没有找到session，则认为登录已经过期，需要重新登录
            err_resp["optype"] = "hall_ready";
            err_resp["reason"] = "登录过期，请重新登录";
            err_resp["result"] = false;
            ws_resp(conn, err_resp);
            return session_ptr();
        }
        return ssp;
    }

    // websocket连接断开的处理回调函数
    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        auto c_code = conn->get_remote_close_code();
        auto c_reason = conn->get_remote_close_code();
        ILOG("wsclose code:%u, reason:%u", c_code, c_reason);
        if (uri == "/hall")
        {
            // 建立了游戏大厅的长连接
            return wsclose_game_hall(conn);
        }
        else if (uri == "/room")
        {
            // 建立了游戏房间的长连接
            return wsclose_game_room(conn);
        }
    }

    // 游戏大厅长连接断开
    void wsclose_game_hall(wsserver_t::connection_ptr conn)
    {
        // 判断当前客户端是否已经成功登录
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 将玩家从游戏大厅中移除
        _om.exit_game_hall(ssp->get_user());
        // 将session恢复生命周期的管理，设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }
    // 游戏房间长连接断开
    void wsclose_game_room(wsserver_t::connection_ptr conn)
    {
        // 获取会话信息，识别客户端
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 将玩家从在线用户管理中移除
        _om.exit_game_room(ssp->get_user());
        // 将玩家从游戏房间中移除，房间中所有用户退出了就会销毁房间
        _rm.remove_room_user(ssp->get_user());
        // 将session回复生命周期的管理，设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    // websocket长连接通信处理回调
    void wsmsg_callback(websocketpp::connection_hdl hdl, wsserver_t::message_ptr msg)
    {
        wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        if (uri == "/hall")
        {
            return wsmsg_game_hall(conn, msg);
        }
        else if (uri == "/room")
        {
            return wsmsg_game_room(conn, msg);
        }
    }

    void wsmsg_game_hall(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        std::string resp_body;
        // 身份验证，当前客户端是哪个玩家
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 获取请求信息
        std::string req_body = msg->get_payload();
        Json::Value req_json;
        bool ret = json_util::deserialize(req_body, req_json);
        if (ret == false)
        {
            resp_json["result"] = false;
            resp_json["reason"] = "请求信息解析失败";
            return ws_resp(conn, resp_json);
        }
        // 对请求进行处理：
        if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start") // 五子棋匹配
        {
            //  开始对战匹配：通过匹配模块，将用户添加到匹配队列中
            _mm.add(ssp->get_user());
            resp_json["optype"] = "match_start";
            resp_json["result"] = true;
            return ws_resp(conn, resp_json);
        }
        else if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop") // 五子棋取消匹配
        {
            //  停止对战匹配：通过匹配模块，将用户从匹配队列中移除
            _mm.del(ssp->get_user());
            resp_json["optype"] = "match_stop";
            resp_json["result"] = true;
            return ws_resp(conn, resp_json);
        }
        else if (!req_json["optype"].isNull() && req_json["optype"].asString() == "match_ai") // 五子棋ai
        {
            // 为玩家创建房间，并将玩家加入房间中
            room_ptr rp = _rm.create_room(UINT64_MAX, ssp->get_user(), false);
            // 对玩家进行响应
            Json::Value resp;
            resp_json["optype"] = "match_success";
            resp_json["result"] = true;
            return ws_resp(conn, resp_json);
        }
        resp_json["optype"] = "unknow";
        resp_json["reason"] = "请求类型未知";
        resp_json["result"] = false;
        return ws_resp(conn, resp_json);
    }
    void wsmsg_game_room(wsserver_t::connection_ptr conn, wsserver_t::message_ptr msg)
    {
        Json::Value resp_json;
        // 获取客户端session，识别客户端身份
        session_ptr ssp = get_session_by_cookie(conn);
        if (ssp.get() == nullptr)
        {
            return;
        }
        // 获取客户端房间信息
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if (rp.get() == nullptr)
        {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "没有找到玩家的房间信息";
            resp_json["result"] = false;
            return ws_resp(conn, resp_json);
        }
        // 对消息进行反序列化
        Json::Value req_json;
        std::string req_body = msg->get_payload();
        bool ret = json_util::deserialize(req_body, req_json);
        if (ret == false)
        {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "请求解析失败";
            resp_json["result"] = false;
            DLOG("房间-反序列化请求失败");
            return ws_resp(conn, resp_json);
        }
        return rp->handle_request(req_json);
    }

private:
    Rpc::Client::RpcClient::ptr _clientp;
    std::string _web_root; // 静态资源根目录 ./wwwroot/
    wsserver_t _wssrv;     // web_socket服务器
    online_manager _om;    // 在线管理模块
    room_manager _rm;      // 房间管理模块
    matcher _mm;           // 匹配队列模块
    session_manager _sm;   // 会话管理模块
};